home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 February: Tool Chest / Apple Developer CD Series Tool Chest February 1996 (Apple Computer)(1996).iso / Tool Chest / Text / WASTE / WASTE 1.1.2 Distribution / Pseudo-UPI for THINK Pascal / TextUtils.p < prev    next >
Encoding:
Text File  |  1995-10-12  |  14.6 KB  |  506 lines  |  [TEXT/PJMM]
  1. unit TextUtils;
  2.  
  3. { Pascal Interface to the Macintosh Libraries }
  4.  
  5. { Copyright © Apple Computer Inc. }
  6. { All Rights Reserved }
  7.  
  8. { Adapted for use with THINK Pascal 4.0.x by Marco Piovanelli }
  9.  
  10. interface
  11.     uses
  12.         Types, IntlResources, OSUtils, QuickdrawText;
  13.  
  14. { New constants for System 7.0: }
  15.  
  16.     const
  17. { Constants for truncWhere argument in TruncString and TruncText }
  18.         truncEnd = 0;                            { Truncate at end }
  19.         truncMiddle = $4000;                        { Truncate in middle }
  20.         smTruncEnd = 0;                            { Truncate at end - obsolete }
  21.         smTruncMiddle = $4000;                        { Truncate in middle - obsolete }
  22. { Constants for TruncString and TruncText results }
  23.         notTruncated = 0;                            { No truncation was necessary }
  24.         truncated = 1;                            { Truncation performed }
  25.         truncErr = -1;                            { General error }
  26.         smNotTruncated = 0;                            { No truncation was necessary - obsolete }
  27.         smTruncated = 1;                            { Truncation performed    - obsolete }
  28.         smTruncErr = -1;                            { General error - obsolete }
  29.  
  30.         fVNumber = 0;                            { first version of NumFormatString }
  31. { Special language code values for Language Order }
  32.         systemCurLang = -2;                            { current (itlbLang) lang for system script }
  33.         systemDefLang = -3;                            { default (table) lang for system script }
  34.         currentCurLang = -4;                            { current (itlbLang) lang for current script }
  35.         currentDefLang = -5;                            { default lang for current script }
  36.         scriptCurLang = -6;                            { current (itlbLang) lang for specified script }
  37.         scriptDefLang = -7;                            { default language for a specified script }
  38.  
  39.         iuSystemCurLang = -2;                            { <obsolete> current (itlbLang) lang for system script }
  40.         iuSystemDefLang = -3;                            { <obsolete> default (table) lang for system script }
  41.         iuCurrentCurLang = -4;                            { <obsolete> current (itlbLang) lang for current script }
  42.         iuCurrentDefLang = -5;                            { <obsolete> default lang for current script }
  43.         iuScriptCurLang = -6;                            { <obsolete> current (itlbLang) lang for specified script }
  44.  
  45. { <obsolete> default language for a specified script }
  46.         iuScriptDefLang = -7;
  47.  
  48.  
  49.     type
  50.         StyledLineBreakCode = SInt8;
  51.  
  52.  
  53.     const
  54.         smBreakWord = 0;
  55.         smBreakChar = 1;
  56.         smBreakOverflow = 2;
  57.  
  58.  
  59.     type
  60.         FormatClass = SInt8;
  61.  
  62.  
  63.     const
  64.         fPositive = 0;
  65.         fNegative = 1;
  66.         fZero = 2;
  67.  
  68.  
  69.     type
  70.         FormatResultType = SInt8;
  71.  
  72.  
  73.     const
  74.         fFormatOK = 0;
  75.         fBestGuess = 1;
  76.         fOutOfSynch = 2;
  77.         fSpuriousChars = 3;
  78.         fMissingDelimiter = 4;
  79.         fExtraDecimal = 5;
  80.         fMissingLiteral = 6;
  81.         fExtraExp = 7;
  82.         fFormatOverflow = 8;
  83.         fFormStrIsNAN = 9;
  84.         fBadPartsTable = 10;
  85.         fExtraPercent = 11;
  86.         fExtraSeparator = 12;
  87.         fEmptyFormatString = 13;
  88.  
  89.  
  90.     type
  91.         NumFormatString = packed record
  92.                 fLength: UInt8;
  93.                 fVersion: UInt8;
  94.                 data: packed array[0..253] of CHAR;            { private data }
  95.             end;
  96.         NumFormatStringRec = NumFormatString;
  97.  
  98.         FVector = record
  99.                 start: INTEGER;
  100.                 length: INTEGER;
  101.             end;
  102. { index by [fPositive..fZero] }
  103.         TripleInt = array[0..2] of FVector;
  104.  
  105.         ScriptRunStatus = record
  106.                 script: SInt8;
  107.                 runVariant: SInt8;
  108.             end;
  109. { New types for System 7.0: }
  110. { Type for truncWhere parameter in new TruncString, TruncText }
  111.         TruncCode = INTEGER;
  112.  
  113.  
  114.     const
  115.         shortDate = 0;
  116.         longDate = 1;
  117.         abbrevDate = 2;
  118.  
  119.  
  120.     type
  121.         DateForm = SInt8;
  122.  
  123.  
  124.     const
  125. { StringToDate status values }
  126.         fatalDateTime = $8000;                        { StringToDate and String2Time mask to a fatal error }
  127.         longDateFound = 1;                            { StringToDate mask to long date found }
  128.         leftOverChars = 2;                            { StringToDate & Time mask to warn of left over characters }
  129.         sepNotIntlSep = 4;                            { StringToDate & Time mask to warn of non-standard separators }
  130.         fieldOrderNotIntl = 8;                            { StringToDate & Time mask to warn of non-standard field order }
  131.         extraneousStrings = 16;                            { StringToDate & Time mask to warn of unparsable strings in text }
  132.         tooManySeps = 32;                            { StringToDate & Time mask to warn of too many separators }
  133.         sepNotConsistent = 64;                            { StringToDate & Time mask to warn of inconsistent separators }
  134.         tokenErr = $8100;                        { StringToDate & Time mask for 'tokenizer err encountered' }
  135.         cantReadUtilities = $8200;
  136.         dateTimeNotFound = $8400;
  137.         dateTimeInvalid = $8800;
  138.  
  139.  
  140.     type
  141.         StringToDateStatus = INTEGER;
  142.  
  143.         String2DateStatus = INTEGER;
  144.  
  145.         DateCacheRecord = packed record
  146.                 hidden: array[0..255] of INTEGER;                { only for temporary use }
  147.             end;
  148.         DateCachePtr = ^DateCacheRecord;
  149.  
  150.         BreakTable = record
  151.                 charTypes: packed array[0..255] of CHAR;
  152.                 tripleLength: INTEGER;
  153.                 triples: array[0..0] of INTEGER;
  154.             end;
  155.         BreakTablePtr = ^BreakTable;
  156.  
  157. { New NBreakTable for System 7.0: }
  158.         NBreakTable = record
  159.                 flags1: SInt8;
  160.                 flags2: SInt8;
  161.                 version: INTEGER;
  162.                 classTableOff: INTEGER;
  163.                 auxCTableOff: INTEGER;
  164.                 backwdTableOff: INTEGER;
  165.                 forwdTableOff: INTEGER;
  166.                 doBackup: INTEGER;
  167.                 length: INTEGER;                                { length of NBreakTable }
  168.                 charTypes: packed array[0..255] of CHAR;
  169.                 tables: array[0..0] of INTEGER;
  170.             end;
  171.         NBreakTablePtr = ^NBreakTable;
  172.  
  173. {}
  174. {    The following functions are new names that work on 68k and PowerPC}
  175. {}
  176.  
  177.     function InitDateCache (theCache: DateCachePtr): OSErr;
  178.     inline
  179.         $2F3C, $8204, $FFF8, $A8B5;
  180.     function ScriptOrder (script1: ScriptCode;
  181.                                     script2: ScriptCode): INTEGER;
  182.     inline
  183.         $3F3C, $001E, $A9ED;
  184.     function StyledLineBreak (textPtr: Ptr;
  185.                                     textLen: LONGINT;
  186.                                     textStart: LONGINT;
  187.                                     textEnd: LONGINT;
  188.                                     flags: LONGINT;
  189.                                     var textWidth: Fixed;
  190.                                     var textOffset: LONGINT): StyledLineBreakCode;
  191.     inline
  192.         $2F3C, $821C, $FFFE, $A8B5;
  193.     function TruncString (width: INTEGER;
  194.                                     var theString: Str255;
  195.                                     truncWhere: TruncCode): INTEGER;
  196.     inline
  197.         $2F3C, $8208, $FFE0, $A8B5;
  198.     function TruncText (width: INTEGER;
  199.                                     textPtr: Ptr;
  200.                                     var length: INTEGER;
  201.                                     truncWhere: TruncCode): INTEGER;
  202.     inline
  203.         $2F3C, $820C, $FFDE, $A8B5;
  204.     function ReplaceText (baseText: Handle;
  205.                                     substitutionText: Handle;
  206.                                     var key: Str15): INTEGER;
  207.     inline
  208.         $2F3C, $820C, $FFDC, $A8B5;
  209.     procedure FindWordBreaks (textPtr: Ptr;
  210.                                     textLength: INTEGER;
  211.                                     offset: INTEGER;
  212.                                     leadingEdge: BOOLEAN;
  213.                                     breaks: BreakTablePtr;
  214.                                     var offsets: OffsetTable;
  215.                                     script: ScriptCode);
  216.     inline
  217.         $2F3C, $C012, $001A, $A8B5;
  218.     procedure LowercaseText (textPtr: Ptr;
  219.                                     len: INTEGER;
  220.                                     script: ScriptCode);
  221.     inline
  222.         $3F3C, $0000, $2F3C, $800A, $FFB6, $A8B5;
  223.     procedure UppercaseText (textPtr: Ptr;
  224.                                     len: INTEGER;
  225.                                     script: ScriptCode);
  226.     inline
  227.         $3F3C, $0400, $2F3C, $800A, $FFB6, $A8B5;
  228.     procedure StripDiacritics (textPtr: Ptr;
  229.                                     len: INTEGER;
  230.                                     script: ScriptCode);
  231.     inline
  232.         $3F3C, $0200, $2F3C, $800A, $FFB6, $A8B5;
  233.     procedure UppercaseStripDiacritics (textPtr: Ptr;
  234.                                     len: INTEGER;
  235.                                     script: ScriptCode);
  236.     inline
  237.         $3F3C, $0600, $2F3C, $800A, $FFB6, $A8B5;
  238.     function FindScriptRun (textPtr: Ptr;
  239.                                     textLen: LONGINT;
  240.                                     var lenUsed: LONGINT): ScriptRunStatus;
  241.     inline
  242.         $2F3C, $820C, $0026, $A8B5;
  243.     function EqualString (str1: ConstStr255Param;
  244.                                     str2: ConstStr255Param;
  245.                                     caseSensitive: BOOLEAN;
  246.                                     diacSensitive: BOOLEAN): BOOLEAN;
  247.     procedure UpperString (var theString: Str255;
  248.                                     diacSensitive: BOOLEAN);
  249.     procedure StringToNum (theString: ConstStr255Param;
  250.                                     var theNum: LONGINT);
  251.     procedure NumToString (theNum: LONGINT;
  252.                                     var theString: Str255);
  253.     function RelString (str1: ConstStr255Param;
  254.                                     str2: ConstStr255Param;
  255.                                     caseSensitive: BOOLEAN;
  256.                                     diacSensitive: BOOLEAN): INTEGER;
  257.     function StringToDate (textPtr: Ptr;
  258.                                     textLen: LONGINT;
  259.                                     theCache: DateCachePtr;
  260.                                     var lengthUsed: LONGINT;
  261.                                     var dateTime: LongDateRec): StringToDateStatus;
  262.     inline
  263.         $2F3C, $8214, $FFF6, $A8B5;
  264.     function StringToTime (textPtr: Ptr;
  265.                                     textLen: LONGINT;
  266.                                     theCache: DateCachePtr;
  267.                                     var lengthUsed: LONGINT;
  268.                                     var dateTime: LongDateRec): StringToDateStatus;
  269.     inline
  270.         $2F3C, $8214, $FFF4, $A8B5;
  271.     function ExtendedToString (var x: extended80; {CONST}
  272.                                     var myCanonical: NumFormatString; {CONST}
  273.                                     var partsTable: NumberParts;
  274.                                     var outString: Str255): FormatStatus;
  275.     inline
  276.         $2F3C, $8210, $FFE8, $A8B5;
  277.     function StringToExtended (source: ConstStr255Param; {CONST}
  278.                                     var myCanonical: NumFormatString; {CONST}
  279.                                     var partsTable: NumberParts;
  280.                                     var x: extended80): FormatStatus;
  281.     inline
  282.         $2F3C, $8210, $FFE6, $A8B5;
  283.     function StringToFormatRec (inString: ConstStr255Param; {CONST}
  284.                                     var partsTable: NumberParts;
  285.                                     var outString: NumFormatString): FormatStatus;
  286.     inline
  287.         $2F3C, $820C, $FFEC, $A8B5;
  288.     function FormatRecToString ({CONST}
  289.                                     var myCanonical: NumFormatString; {CONST}
  290.                                     var partsTable: NumberParts;
  291.                                     var outString: Str255;
  292.                                     var positions: TripleInt): FormatStatus;
  293.     inline
  294.         $2F3C, $8210, $FFEA, $A8B5;
  295.  
  296. {    The following functions are old names, but are required for PowerPC builds }
  297. {    becuase InterfaceLib exports these names, instead of the new ones.}
  298.  
  299.     function IUMagString (aPtr: univ Ptr;
  300.                                     bPtr: univ Ptr;
  301.                                     aLen: INTEGER;
  302.                                     bLen: INTEGER): INTEGER;
  303.     inline
  304.         $3F3C, $000A, $A9ED;
  305.     function IUMagIDString (aPtr: univ Ptr;
  306.                                     bPtr: univ Ptr;
  307.                                     aLen: INTEGER;
  308.                                     bLen: INTEGER): INTEGER;
  309.     inline
  310.         $3F3C, $000C, $A9ED;
  311.     function IUMagPString (aPtr: univ Ptr;
  312.                                     bPtr: univ Ptr;
  313.                                     aLen: INTEGER;
  314.                                     bLen: INTEGER;
  315.                                     itl2Handle: Handle): INTEGER;
  316.     inline
  317.         $3F3C, $001A, $A9ED;
  318.     function IUMagIDPString (aPtr: univ Ptr;
  319.                                     bPtr: univ Ptr;
  320.                                     aLen: INTEGER;
  321.                                     bLen: INTEGER;
  322.                                     itl2Handle: Handle): INTEGER;
  323.     inline
  324.         $3F3C, $001C, $A9ED;
  325.     procedure IUDateString (dateTime: LONGINT;
  326.                                     longFlag: ByteParameter;
  327.                                     var result: Str255);
  328.     inline
  329.         $4267, $A9ED;
  330.     procedure IUTimeString (dateTime: LONGINT;
  331.                                     wantSeconds: BOOLEAN;
  332.                                     var result: Str255);
  333.     inline
  334.         $3F3C, $0002, $A9ED;
  335.     procedure IUDatePString (dateTime: LONGINT;
  336.                                     longFlag: ByteParameter;
  337.                                     var result: Str255;
  338.                                     intlHandle: Handle);
  339.     inline
  340.         $3F3C, $000E, $A9ED;
  341.     procedure IUTimePString (dateTime: LONGINT;
  342.                                     wantSeconds: BOOLEAN;
  343.                                     var result: Str255;
  344.                                     intlHandle: Handle);
  345.     inline
  346.         $3F3C, $0010, $A9ED;
  347.     procedure IULDateString (var dateTime: LongDateTime;
  348.                                     longFlag: ByteParameter;
  349.                                     var result: Str255;
  350.                                     intlHandle: Handle);
  351.     inline
  352.         $3F3C, $0014, $A9ED;
  353.     procedure IULTimeString (var dateTime: LongDateTime;
  354.                                     wantSeconds: BOOLEAN;
  355.                                     var result: Str255;
  356.                                     intlHandle: Handle);
  357.     inline
  358.         $3F3C, $0016, $A9ED;
  359.     function IUScriptOrder (script1: ScriptCode;
  360.                                     script2: ScriptCode): INTEGER;
  361.     inline
  362.         $3F3C, $001E, $A9ED;
  363.     function IULangOrder (language1: LangCode;
  364.                                     language2: LangCode): INTEGER;
  365.     inline
  366.         $3F3C, $0020, $A9ED;
  367.     function IUTextOrder (aPtr: univ Ptr;
  368.                                     bPtr: univ Ptr;
  369.                                     aLen: INTEGER;
  370.                                     bLen: INTEGER;
  371.                                     aScript: ScriptCode;
  372.                                     bScript: ScriptCode;
  373.                                     aLang: LangCode;
  374.                                     bLang: LangCode): INTEGER;
  375.     inline
  376.         $3F3C, $0022, $A9ED;
  377.     procedure FindWord (textPtr: Ptr;
  378.                                     textLength: INTEGER;
  379.                                     offset: INTEGER;
  380.                                     leadingEdge: BOOLEAN;
  381.                                     breaks: BreakTablePtr;
  382.                                     var offsets: OffsetTable);
  383.     inline
  384.         $2F3C, $8012, $001A, $A8B5;
  385.     procedure NFindWord (textPtr: Ptr;
  386.                                     textLength: INTEGER;
  387.                                     offset: INTEGER;
  388.                                     leadingEdge: BOOLEAN;
  389.                                     nbreaks: NBreakTablePtr;
  390.                                     var offsets: OffsetTable);
  391.     inline
  392.         $2F3C, $8012, $FFE2, $A8B5;
  393.     procedure UprText (textPtr: Ptr;
  394.                                     len: INTEGER);
  395.     inline
  396.         $301F, $205F, $A054;
  397.     procedure LwrText (textPtr: Ptr;
  398.                                     len: INTEGER);
  399.     inline
  400.         $301F, $205F, $A056;
  401.     procedure LowerText (textPtr: Ptr;
  402.                                     len: INTEGER);
  403.     inline
  404.         $301F, $205F, $A056;
  405.     procedure StripText (textPtr: Ptr;
  406.                                     len: INTEGER);
  407.     inline
  408.         $301F, $205F, $A256;
  409.     procedure UpperText (textPtr: Ptr;
  410.                                     len: INTEGER);
  411.     inline
  412.         $301F, $205F, $A456;
  413.     procedure StripUpperText (textPtr: Ptr;
  414.                                     len: INTEGER);
  415.     inline
  416.         $301F, $205F, $A656;
  417.     function IUCompPString (aStr: ConstStr255Param;
  418.                                     bStr: ConstStr255Param;
  419.                                     itl2Handle: Handle): INTEGER;
  420.     function IUEqualPString (aStr: ConstStr255Param;
  421.                                     bStr: ConstStr255Param;
  422.                                     itl2Handle: Handle): INTEGER;
  423.     function IUStringOrder (aStr: ConstStr255Param;
  424.                                     bStr: ConstStr255Param;
  425.                                     aScript: ScriptCode;
  426.                                     bScript: ScriptCode;
  427.                                     aLang: LangCode;
  428.                                     bLang: LangCode): INTEGER;
  429.     function IUCompString (aStr: ConstStr255Param;
  430.                                     bStr: ConstStr255Param): INTEGER;
  431.     function IUEqualString (aStr: ConstStr255Param;
  432.                                     bStr: ConstStr255Param): INTEGER;
  433. {}
  434. {    The following provide direct function prototypes for new names for 68k}
  435. {}
  436.     procedure DateString (dateTime: LONGINT;
  437.                                     longFlag: ByteParameter;
  438.                                     var result: Str255;
  439.                                     intlHandle: Handle);
  440.     inline
  441.         $3F3C, $000E, $A9ED;
  442.     procedure TimeString (dateTime: LONGINT;
  443.                                     wantSeconds: BOOLEAN;
  444.                                     var result: Str255;
  445.                                     intlHandle: Handle);
  446.     inline
  447.         $3F3C, $0010, $A9ED;
  448.     procedure LongDateString (var dateTime: LongDateTime;
  449.                                     longFlag: ByteParameter;
  450.                                     var result: Str255;
  451.                                     intlHandle: Handle);
  452.     inline
  453.         $3F3C, $0014, $A9ED;
  454.     procedure LongTimeString (var dateTime: LongDateTime;
  455.                                     wantSeconds: BOOLEAN;
  456.                                     var result: Str255;
  457.                                     intlHandle: Handle);
  458.     inline
  459.         $3F3C, $0016, $A9ED;
  460.     function CompareString (aStr: ConstStr255Param;
  461.                                     bStr: ConstStr255Param;
  462.                                     itl2Handle: Handle): INTEGER;
  463.     function IdenticalString (aStr: ConstStr255Param;
  464.                                     bStr: ConstStr255Param;
  465.                                     itl2Handle: Handle): INTEGER;
  466.     function CompareText (aPtr: univ Ptr;
  467.                                     bPtr: univ Ptr;
  468.                                     aLen: INTEGER;
  469.                                     bLen: INTEGER;
  470.                                     itl2Handle: Handle): INTEGER;
  471.     inline
  472.         $3F3C, $001A, $A9ED;
  473.     function IdenticalText (aPtr: univ Ptr;
  474.                                     bPtr: univ Ptr;
  475.                                     aLen: INTEGER;
  476.                                     bLen: INTEGER;
  477.                                     itl2Handle: Handle): INTEGER;
  478.     inline
  479.         $3F3C, $001C, $A9ED;
  480.     function LanguageOrder (language1: LangCode;
  481.                                     language2: LangCode): INTEGER;
  482.     inline
  483.         $3F3C, $0020, $A9ED;
  484.     function TextOrder (aPtr: univ Ptr;
  485.                                     bPtr: univ Ptr;
  486.                                     aLen: INTEGER;
  487.                                     bLen: INTEGER;
  488.                                     aScript: ScriptCode;
  489.                                     bScript: ScriptCode;
  490.                                     aLang: LangCode;
  491.                                     bLang: LangCode): INTEGER;
  492.     inline
  493.         $3F3C, $0022, $A9ED;
  494.     function StringOrder (aStr: ConstStr255Param;
  495.                                     bStr: ConstStr255Param;
  496.                                     aScript: ScriptCode;
  497.                                     bScript: ScriptCode;
  498.                                     aLang: LangCode;
  499.                                     bLang: LangCode): INTEGER;
  500.     procedure C2PStrProc (aStr: univ Ptr);
  501.     function C2PStr (cString: univ Ptr): StringPtr;
  502.     procedure P2CStrProc (aStr: StringPtr);
  503.     function P2CStr (pString: StringPtr): Ptr;
  504.  
  505. implementation
  506. end.